//
// Created by cen on 2025/8/15.
//

// C++11 新特性学习

#include <iostream>
#include <vector>
#include <cstring>
#include <algorithm>

using namespace std;


class Stu {
public:
    Stu(string _name, int _age) : name(_name), age(_age) {
        cout << "构造函数" << endl;
    }

    Stu(const Stu &stu) {
        cout << "== 左值拷贝 ==" << endl;
        name = stu.name;
        age = stu.age;
    }

    Stu(Stu &&stu) {
        cout << "== 右值拷贝 ==" << endl;
        name = stu.name;
        age = stu.age;
    }

    void printInfo() {
        cout << name << ":" << age << endl;
    }


private:
    string name;
    int age;
};

Stu getTemp() {
    return Stu("John", 22);
}

namespace String {
    class string {
    public:
        typedef char *iterator;

        iterator begin() {
            return _str;
        }

        iterator end() {
            return _str + _size;
        }

        // 构造函数
        string(const char *str = "") {
            _size = strlen(str);
            _capacity = _size;
            _str = new char[_capacity + 1]; //（多开一个用于存放'\0'）
            strcpy(_str, str);
        }

        // 交换两个对象的数据
        void swap(string &s) {
            // 调用库里的swap
            ::swap(_str, s._str); //交换两个对象的C字符串
            ::swap(_size, s._size); //交换两个对象的大小
            ::swap(_capacity, s._capacity); //交换两个对象的容量
        }

        // 拷贝构造函数
        string(const string &s)
                : _str(nullptr), _size(0), _capacity(0) {
            cout << "string(const string& s) -- 深拷贝" << endl;

            string tmp(s._str); //调用构造函数，构造出一个C字符串为s._str的对象
            swap(tmp); //交换这两个对象
        }

        // 赋值运算符重载
        string &operator=(const string &s) {
            cout << "string& operator=(const string& s) -- 深拷贝" << endl;

            string tmp(s); //用s拷贝构造出对象tmp
            swap(tmp); //交换这两个对象
            return *this; //返回左值（支持连续赋值）
        }

        //析构函数
        ~string() {
            delete[] _str;  // 释放_str
            _str = nullptr;
            _size = 0;
            _capacity = 0;
        }


    private:
        char *_str;
        size_t _size;
        size_t _capacity;
    };
}

void Func(int &x) {
    cout << "左值引用" << endl;
}

void Func(const int &x) {
    cout << "const 左值引用" << endl;
}

void Func(int &&x) {
    cout << "右值引用" << endl;
}

void Func(const int &&x) {
    cout << "const 右值引用" << endl;
}

template<class T>
void PerfectForward(T &&t) {
    Func(t);
}

//int main() {
//    int a = 10;
//    PerfectForward(a);       //左值
//    PerfectForward(move(a)); //右值
//
//    const int b = 20;
//    PerfectForward(b);       //const 左值
//    PerfectForward(move(b)); //const 右值
//
//    return 0;
//}


//int main() {
// Stu stu2(stu1); error

// 左值
//    int a = 100;
//    int& b = a;
//    // 右值
//    int&& c = 100;
//
//    const int& d = 100;
//    int&& e = move(a);
//
//    cout << b;

//    Stu stu1("Mike", 23);
//    Stu stu2(move(stu1));
//
//    stu1.printInfo();
//    cout << &stu1 << endl;
//    stu2.printInfo();
//    cout << &stu2 << endl;

//    return 0;
//}

// lambda 表达式

template<class T>
class greaterSort {
public:
    bool operator()(const T &num1, const T &num2) {
        return num1 < num2;
    }
};

template<class T>
bool lessSort(const T &num1, const T &num2) {
    return num1 > num2;
}

int main() {
    vector<int> nums = {3, 5, 8, 9, 33, 1, 100};
    // sort(nums.begin(), nums.end(), greaterSort<int>());
    // sort(nums.begin(), nums.end(), lessSort<int>);
    sort(nums.begin(), nums.end(), [](const int &num1, const int &num2) -> bool{
        return num1 > num2;
    });
    for(auto& i : nums) {
        cout << i << " ";
    }
    return 0;
}


